import { isString } from 'lodash';
import { isNumeric, isPercent } from './NumericUtil';

/**
 * Echarts 报表库里的方法，千分位，加逗号分隔
 * @param value
 * @returns
 */

export const eAddCommas = (value: any) => {
  if (!isNumeric(value)) {
    return isString(value) ? value : '-';
  }

  const [integer, decimal] = (value + '').split('.');
  return (
    integer.replace(/(\d{1,3})(?=(?:\d{3})+(?!\d))/g, '$1,') +
    (decimal ? `.${decimal}` : '')
  );
};

/**
 * 格式化数字，以加','分隔
 * @param value
 * @param digit
 * @returns
 */
export function addCommas(
  value: string | number,
  digit: number = 2,
  forceDigit?: boolean,
) {
  let val = value;

  if (isNumeric(value)) {
    val = value.toLocaleString('en-US', {
      minimumFractionDigits: forceDigit ? digit : 0,
      maximumFractionDigits: digit,
    });
  } else if (
    isString(value) &&
    /^([+|-])?([0-9]+)(,[0-9]+)*(.[0-9]+)?$/g.test(
      String(value).replace('.', ''),
    )
  ) {
    val = eAddCommas(value);
  }

  // 需要强制保留小数点的时候，如果是整数会自动补0
  if (forceDigit && digit) {
    const valList = String(val).split('.');

    if (valList.length === 1) {
      // 返回的是整数时，自动填充对应位数0
      val = val + '.'.padEnd(digit + 1, '0');
    } else {
      // 返回的小数点超过设定位数时，则截取到保留的小数点位数
      if (valList[1].length > digit) {
        val = [valList[0], valList[1].slice(0, digit)].join('.');
      }
    }
  }

  return val;
}

/**
 * 格式化文件大小
 * @param value 要格式化数字
 * @param digit 保留小数点几位
 * @param unitSize 默认单元大小：1024、1000，存储服务器上文件大小是按1000计算，而不是1024
 * @param forceDigit 是否强制补齐两位小数
 * @returns
 */
export const formatSize = (
  value: string | number,
  digit = 2,
  unitSize: number = 1024,
  forceDigit?: boolean,
) => {
  const formatUnit = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];

  let size: string | number = '';
  let unit: string = '';

  if (value !== undefined) {
    size = String(value).replace(',', '');

    if (isNumeric(value)) {
      let index = 0;
      const srcSize = Number.parseFloat(String(value));

      index = Math.floor(Math.log(srcSize) / Math.log(unitSize));
      // 如果val值小于1，index为-1
      if (index >= 0) {
        size = srcSize / Math.pow(unitSize, index);
        unit = formatUnit[index];
      } else {
        size = srcSize;
      }

      size = addCommas(size, digit, forceDigit);
    } else {
      if (isPercent(value)) {
        size = value;
      } else {
        size = '-';
      }
    }
  }

  return {
    size,
    unit,
  };
};

type IFormatOption = {
  units?: string[];
  dividend?: number;
};
type IFormatRes = {
  value: string | number;
  unit: string;
};

export function formatByte(
  val: string | number,
  digit: number = 2,
  options: IFormatOption = {},
): IFormatRes {
  const {
    units = ['', '万', '亿', '兆', '京', '垓', '秭', '穰', '僧'],
    dividend = 1e4,
  } = options;

  let value: string | number = val;
  let unit: string = '';
  const hasComma = `${value}`.indexOf(',') > -1;

  if (hasComma) {
    value = `${value}`.replace(/,/g, '');
  }

  if (isNaN(Number(value))) {
    value = `${value}`.slice(-1) === '%' ? value : '-';
  } else {
    const srcValue = Number.parseFloat(`${value}`);
    const index = Math.max(
      0,
      Math.floor(Math.log(srcValue) / Math.log(dividend)),
    );

    value = srcValue / Math.pow(dividend, index);
    unit = units[index];
  }

  value = addCommas(value, digit);

  return { value, unit };
}
